# search.py
# ---------
# Licensing Information: Please do not distribute or publish solutions to this
# project. You are free to use and extend these projects for educational
# purposes. The Pacman AI projects were developed at UC Berkeley, primarily by
# John DeNero (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu).
# For more info, see http://inst.eecs.berkeley.edu/~cs188/sp09/pacman.html

"""
In search.py, you will implement generic search algorithms which are called 
by Pacman agents (in searchAgents.py).
"""

import util

class SearchProblem:
  """
  This class outlines the structure of a search problem, but doesn't implement
  any of the methods (in object-oriented terminology: an abstract class).
  
  You do not need to change anything in this class, ever.
  """
  
  def getStartState(self):
     """
     Returns the start state for the search problem 
     """
     util.raiseNotDefined()
    
  def isGoalState(self, state):
     """
       state: Search state
    
     Returns True if and only if the state is a valid goal state
     """
     util.raiseNotDefined()

  def getSuccessors(self, state):
     """
       state: Search state
     
     For a given state, this should return a list of triples, 
     (successor, action, stepCost), where 'successor' is a 
     successor to the current state, 'action' is the action
     required to get there, and 'stepCost' is the incremental 
     cost of expanding to that successor
     """
     util.raiseNotDefined()

  def getCostOfActions(self, actions):
     """
      actions: A list of actions to take
 
     This method returns the total cost of a particular sequence of actions.  The sequence must
     be composed of legal moves
     """
     util.raiseNotDefined()
           

def tinyMazeSearch(problem):
  """
  Returns a sequence of moves that solves tinyMaze.  For any other
  maze, the sequence of moves will be incorrect, so only use this for tinyMaze
  """
  from game import Directions
  s = Directions.SOUTH
  w = Directions.WEST
  return  [s,s,w,s,w,w,s,w]

def depthFirstSearch(problem):
  """
  Search the deepest nodes in the search tree first [p 85].
  
  Your search algorithm needs to return a list of actions that reaches
  the goal.  Make sure to implement a graph search algorithm [Fig. 3.7].
  
  To get started, you might want to try some of these simple commands to
  understand the search problem that is being passed in:
  
  print "Start:", problem.getStartState()
  print "Is the start a goal?", problem.isGoalState(problem.getStartState())
  print "Start's successors:", problem.getSuccessors(problem.getStartState())
  """
  "*** YOUR CODE HERE ***"
  currentState = problem.getStartState()

  fringeList = util.Stack() # use a stack as fringe
  explored = []
  fringeState = []
  netPath = util.Stack()
  path = [] # store all expanded nodes and its information
  parentList =[]
  childList = []
  actionList = []

  while not problem.isGoalState(currentState):
      explored.append(currentState)
      successors = problem.getSuccessors(currentState) # get successors of Current State
      for i in successors:
          if i[0] not in fringeState:   # If successor is already in fringe list, do not push into the stack
              if i[0] not in explored:  # If successor is already visited, do not push into the stack
                  fringeList.push(i)    # push successors into stack
                  fringeState.append(i[0])  # update fringe state list
                  # store all parent and its child node info to find proper path
                  parentList.append(currentState)
                  childList.append(i[0])
      temp = fringeList.pop()
      # store all expanded nodes list
      path.append(temp)
      # get information of a child state
      currentState = temp[0]

  "Find net path and action list"
  # back tracking from the goal node to the start node
  node = currentState
  # repeat until get start node
  while not node == problem.getStartState():
      for p in path:
          if node == p[0]:
              netPath.push(p[1])  # Push action info to get node into stack
              break
      index = childList.index(node)
      node = parentList[index] # find parent node

  while not netPath.isEmpty():
      actionList.append(netPath.pop())

  return actionList
  #util.raiseNotDefined()

def breadthFirstSearch(problem):
  "Search the shallowest nodes in the search tree first. [p 81]"
  "*** YOUR CODE HERE ***"
  currentState = problem.getStartState()

  fringeList = util.Queue() # use a queue as fringe
  explored = []
  fringeState = []
  netPath = util.Stack()
  path = [] # store all expanded nodes and its information
  parentList =[]
  childList = []
  actionList = []

  while not problem.isGoalState(currentState): # get successors of Current State
      explored.append(currentState)
      successors = problem.getSuccessors(currentState)
      for i in successors:
          if i[0] not in fringeState:   # If successor is already in fringe list, do not push into the queue
              if i[0] not in explored:  # If successor is already visited, do not push into the queue
                  fringeList.push(i)    # push successors into the queue
                  fringeState.append(i[0]) # update fringe state list
                  # store all parent and its child node info to find proper path
                  parentList.append(currentState)
                  childList.append(i[0])

      temp = fringeList.pop()
      # store all expanded nodes list
      path.append(temp)
      # get information of a child state
      currentState = temp[0]

  "Find net path and action list"
  # back tracking from the goal node to the start node
  node = currentState
  # repeat until get start node
  while not node == problem.getStartState():
      for p in path:
          if node == p[0]:
              netPath.push(p[1])    # Push action info to get node into stack
              break
      index = childList.index(node)
      node = parentList[index]  # find parent node

  while not netPath.isEmpty():
      actionList.append(netPath.pop())

  return actionList
  #util.raiseNotDefined()
      
def uniformCostSearch(problem):
  "Search the node of least total cost first. "
  "*** YOUR CODE HERE ***"
  currentState = problem.getStartState()

  fringeList = util.PriorityQueue() # use a priority queue as fringe
  explored = []
  fringeState = []
  netPath = util.Stack()
  path = [] # store all expanded nodes and its information
  parentList =[]
  childList = []
  actionList = []
  priority = 0
  root = (currentState,'',priority)
  fringeList.push(root, priority)
  
  while not fringeList.isEmpty():
      temp = fringeList.pop()
      currentState = temp[0]
      priority =temp[2]
      path.append(temp)
      if  problem.isGoalState(currentState):
          break
      explored.append(currentState)
      successors = problem.getSuccessors(currentState)
      for state, action, cost in successors:
          if state not in fringeState:   # If successor is already in fringe list, do not push into the priority queue
              if state not in explored:  # If successor is already visited, do not push into the priority queue
                  cost += priority      # update cost info
                  fringeList.push((state,action,cost),cost)   # push successors and cost into the priority queue
                  fringeState.append(state) #  update fringe state list
                   # store all parent and its child node info to find proper path
                  parentList.append(currentState)
                  childList.append(state)
  "Find net path and action list"
  # back tracking from the goal node to the start node
  node = currentState
  # repeat until get start node
  while not node == problem.getStartState():
      for p in path:
          if node == p[0]:
              netPath.push(p[1])    # Push action info to get node into stack
              break
      index = childList.index(node)
      node = parentList[index]  # find parent node

  while not netPath.isEmpty():
      actionList.append(netPath.pop())

  return actionList
  #util.raiseNotDefined()

def nullHeuristic(state, problem=None):
  """
  A heuristic function estimates the cost from the current state to the nearest
  goal in the provided SearchProblem.  This heuristic is trivial.
  """
  return 0

def aStarSearch(problem, heuristic=nullHeuristic):
  "Search the node that has the lowest combined cost and heuristic first."
  "*** YOUR CODE HERE ***"
  currentState = problem.getStartState()
  fringeList = util.PriorityQueue() # use a priority queue as fringe
  explored = []
  fringeState = []
  netPath = util.Stack()
  path = [] # store all expanded nodes and its information
  parentList =[]
  childList = []
  actionList = []
  priority = 0
  root = (currentState,'',priority)
  fringeList.push(root, priority)

  while not fringeList.isEmpty():
      temp = fringeList.pop()
      currentState = temp[0]
      priority = temp[2]
      path.append(temp)
      if  problem.isGoalState(currentState):
          break
      explored.append(currentState)
      successors = problem.getSuccessors(currentState)
      for state, action, cost in  successors:
          if state not in fringeState:   # If successor is already in fringe list, do not push into the priority queue
              if state not in explored:  # If successor is already visited, do not push into the priority queue
                  # update cost info
                  cost += priority
                  fringeList.push((state,action,cost),cost + heuristic(state,problem))   # push successors and cost into the priority queue
                  fringeState.append(state) #  update fringe state list
                   # store all parent and its child node info to find proper path
                  parentList.append(currentState)
                  childList.append(state)
  "Find net path and action list"
  # back tracking from the goal node to the start node
  node = currentState
  # repeat until get start node
  while not node == problem.getStartState():
      for p in path:
          if node == p[0]:
              netPath.push(p[1])    # Push action info to get node into stack
              break
      index = childList.index(node)
      node = parentList[index]  # find parent node
  while not netPath.isEmpty():
      actionList.append(netPath.pop())
  return actionList
  #util.raiseNotDefined()
  
# Abbreviations
bfs = breadthFirstSearch
dfs = depthFirstSearch
astar = aStarSearch
ucs = uniformCostSearch
